/*********************************************************/
/*
	delegate
	TEMPLATE_ARGS = 
	FUNCTION_ARGS = 
	FUNCTION_PARA = 
	CLASS_MEMBER  =  
	CLASS_MEMBER_ASSIGN  = 
	CLASS_MEMBER_PARA    = 
*/
template<typename BindType, typename ClassType, typename Ret >
class delegate<Ret(), BindType, ClassType>
{
public:
	typedef functor<Ret(), BindType, ClassType> functor_type;
	typedef typename functor_type::return_type return_type;

	delegate(const functor_type& _functor )
		:functor_(_functor) 
	{

	}

	Ret operator()()
	{
		return functor_();
	}

	Ret Do()
	{
		return functor_();
	}

	functor_type& getFunctor() {return functor_;}

private:
	functor_type functor_;

	;

	delegate(const delegate&);
	delegate& operator=(const delegate&);
};

/*
	delegate_list
	TEMPLATE_ARGS = 
	FUNCTION_ARGS = 
	FUNCTION_PARA = 
	CLASS_MEMBER  =  
	CLASS_MEMBER_ASSIGN  = 
	CLASS_MEMBER_PARA    = 
*/
template<typename BindType, typename ClassType, typename Ret >
class delegate_list<Ret(), BindType, ClassType>
{
public:
	typedef functor_list<Ret(), BindType, ClassType> functor_list_type;
	typedef functor<Ret(), BindType, ClassType> functor_type;
	typedef typename functor_type::return_type return_type;

	delegate_list(const functor_type& _functor )
		:functor_(_functor) 
	{
	}

	Ret operator()()
	{
		return functor_();
	}

	functor_list_type& getFunctor() {return functor_;}

private:
	functor_list_type functor_;

	;

	delegate_list(const delegate_list&);
	delegate_list& operator=(const delegate_list&);
};

/*
	delegate_type
	TEMPLATE_ARGS = 
	FUNCTION_ARGS = 
 */
template<typename BindType, typename RtVal, typename ClassType >
struct delegate_type<RtVal (ClassType::*)(), BindType>
{
	typedef delegate<RtVal (), BindType, ClassType> type;
	typedef delegate_list<RtVal (), BindType, ClassType> list_type;
};

template<typename BindType, typename RtVal >
struct delegate_type<RtVal (*)(), BindType>
{
	typedef delegate<RtVal (), BindType, ClassStub> type;
	typedef delegate_list<RtVal (), BindType, ClassStub> list_type;
};




/*********************************************************/

/*********************************************************/
/*
	delegate
	TEMPLATE_ARGS = , typename T0
	FUNCTION_ARGS = T0 t0
	FUNCTION_PARA = ,T0 t0
	CLASS_MEMBER  = T0 t0_; 
	CLASS_MEMBER_ASSIGN  = , t0_(t0)
	CLASS_MEMBER_PARA    = t0_
*/
template<typename BindType, typename ClassType, typename Ret , typename T0>
class delegate<Ret(T0 t0), BindType, ClassType>
{
public:
	typedef functor<Ret(T0 t0), BindType, ClassType> functor_type;
	typedef typename functor_type::return_type return_type;

	delegate(const functor_type& _functor ,T0 t0)
		:functor_(_functor) , t0_(t0)
	{

	}

	Ret operator()()
	{
		return functor_(t0_);
	}

	Ret Do()
	{
		return functor_(t0_);
	}

	functor_type& getFunctor() {return functor_;}

private:
	functor_type functor_;

	T0 t0_;;

	delegate(const delegate&);
	delegate& operator=(const delegate&);
};

/*
	delegate_list
	TEMPLATE_ARGS = , typename T0
	FUNCTION_ARGS = T0 t0
	FUNCTION_PARA = ,T0 t0
	CLASS_MEMBER  = T0 t0_; 
	CLASS_MEMBER_ASSIGN  = , t0_(t0)
	CLASS_MEMBER_PARA    = t0_
*/
template<typename BindType, typename ClassType, typename Ret , typename T0>
class delegate_list<Ret(T0 t0), BindType, ClassType>
{
public:
	typedef functor_list<Ret(T0 t0), BindType, ClassType> functor_list_type;
	typedef functor<Ret(T0 t0), BindType, ClassType> functor_type;
	typedef typename functor_type::return_type return_type;

	delegate_list(const functor_type& _functor ,T0 t0)
		:functor_(_functor) , t0_(t0)
	{
	}

	Ret operator()()
	{
		return functor_(t0_);
	}

	functor_list_type& getFunctor() {return functor_;}

private:
	functor_list_type functor_;

	T0 t0_;;

	delegate_list(const delegate_list&);
	delegate_list& operator=(const delegate_list&);
};

/*
	delegate_type
	TEMPLATE_ARGS = , typename T0
	FUNCTION_ARGS = T0 t0
 */
template<typename BindType, typename RtVal, typename ClassType , typename T0>
struct delegate_type<RtVal (ClassType::*)(T0 t0), BindType>
{
	typedef delegate<RtVal (T0 t0), BindType, ClassType> type;
	typedef delegate_list<RtVal (T0 t0), BindType, ClassType> list_type;
};

template<typename BindType, typename RtVal , typename T0>
struct delegate_type<RtVal (*)(T0 t0), BindType>
{
	typedef delegate<RtVal (T0 t0), BindType, ClassStub> type;
	typedef delegate_list<RtVal (T0 t0), BindType, ClassStub> list_type;
};




/*********************************************************/

/*********************************************************/
/*
	delegate
	TEMPLATE_ARGS = , typename T0, typename T1
	FUNCTION_ARGS = T0 t0, T1 t1
	FUNCTION_PARA = ,T0 t0, T1 t1
	CLASS_MEMBER  = T0 t0_;T1 t1_; 
	CLASS_MEMBER_ASSIGN  = , t0_(t0), t1_(t1)
	CLASS_MEMBER_PARA    = t0_, t1_
*/
template<typename BindType, typename ClassType, typename Ret , typename T0, typename T1>
class delegate<Ret(T0 t0, T1 t1), BindType, ClassType>
{
public:
	typedef functor<Ret(T0 t0, T1 t1), BindType, ClassType> functor_type;
	typedef typename functor_type::return_type return_type;

	delegate(const functor_type& _functor ,T0 t0, T1 t1)
		:functor_(_functor) , t0_(t0), t1_(t1)
	{

	}

	Ret operator()()
	{
		return functor_(t0_, t1_);
	}

	Ret Do()
	{
		return functor_(t0_, t1_);
	}

	functor_type& getFunctor() {return functor_;}

private:
	functor_type functor_;

	T0 t0_;T1 t1_;;

	delegate(const delegate&);
	delegate& operator=(const delegate&);
};

/*
	delegate_list
	TEMPLATE_ARGS = , typename T0, typename T1
	FUNCTION_ARGS = T0 t0, T1 t1
	FUNCTION_PARA = ,T0 t0, T1 t1
	CLASS_MEMBER  = T0 t0_;T1 t1_; 
	CLASS_MEMBER_ASSIGN  = , t0_(t0), t1_(t1)
	CLASS_MEMBER_PARA    = t0_, t1_
*/
template<typename BindType, typename ClassType, typename Ret , typename T0, typename T1>
class delegate_list<Ret(T0 t0, T1 t1), BindType, ClassType>
{
public:
	typedef functor_list<Ret(T0 t0, T1 t1), BindType, ClassType> functor_list_type;
	typedef functor<Ret(T0 t0, T1 t1), BindType, ClassType> functor_type;
	typedef typename functor_type::return_type return_type;

	delegate_list(const functor_type& _functor ,T0 t0, T1 t1)
		:functor_(_functor) , t0_(t0), t1_(t1)
	{
	}

	Ret operator()()
	{
		return functor_(t0_, t1_);
	}

	functor_list_type& getFunctor() {return functor_;}

private:
	functor_list_type functor_;

	T0 t0_;T1 t1_;;

	delegate_list(const delegate_list&);
	delegate_list& operator=(const delegate_list&);
};

/*
	delegate_type
	TEMPLATE_ARGS = , typename T0, typename T1
	FUNCTION_ARGS = T0 t0, T1 t1
 */
template<typename BindType, typename RtVal, typename ClassType , typename T0, typename T1>
struct delegate_type<RtVal (ClassType::*)(T0 t0, T1 t1), BindType>
{
	typedef delegate<RtVal (T0 t0, T1 t1), BindType, ClassType> type;
	typedef delegate_list<RtVal (T0 t0, T1 t1), BindType, ClassType> list_type;
};

template<typename BindType, typename RtVal , typename T0, typename T1>
struct delegate_type<RtVal (*)(T0 t0, T1 t1), BindType>
{
	typedef delegate<RtVal (T0 t0, T1 t1), BindType, ClassStub> type;
	typedef delegate_list<RtVal (T0 t0, T1 t1), BindType, ClassStub> list_type;
};




/*********************************************************/

/*********************************************************/
/*
	delegate
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2
	FUNCTION_PARA = ,T0 t0, T1 t1, T2 t2
	CLASS_MEMBER  = T0 t0_;T1 t1_;T2 t2_; 
	CLASS_MEMBER_ASSIGN  = , t0_(t0), t1_(t1), t2_(t2)
	CLASS_MEMBER_PARA    = t0_, t1_, t2_
*/
template<typename BindType, typename ClassType, typename Ret , typename T0, typename T1, typename T2>
class delegate<Ret(T0 t0, T1 t1, T2 t2), BindType, ClassType>
{
public:
	typedef functor<Ret(T0 t0, T1 t1, T2 t2), BindType, ClassType> functor_type;
	typedef typename functor_type::return_type return_type;

	delegate(const functor_type& _functor ,T0 t0, T1 t1, T2 t2)
		:functor_(_functor) , t0_(t0), t1_(t1), t2_(t2)
	{

	}

	Ret operator()()
	{
		return functor_(t0_, t1_, t2_);
	}

	Ret Do()
	{
		return functor_(t0_, t1_, t2_);
	}

	functor_type& getFunctor() {return functor_;}

private:
	functor_type functor_;

	T0 t0_;T1 t1_;T2 t2_;;

	delegate(const delegate&);
	delegate& operator=(const delegate&);
};

/*
	delegate_list
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2
	FUNCTION_PARA = ,T0 t0, T1 t1, T2 t2
	CLASS_MEMBER  = T0 t0_;T1 t1_;T2 t2_; 
	CLASS_MEMBER_ASSIGN  = , t0_(t0), t1_(t1), t2_(t2)
	CLASS_MEMBER_PARA    = t0_, t1_, t2_
*/
template<typename BindType, typename ClassType, typename Ret , typename T0, typename T1, typename T2>
class delegate_list<Ret(T0 t0, T1 t1, T2 t2), BindType, ClassType>
{
public:
	typedef functor_list<Ret(T0 t0, T1 t1, T2 t2), BindType, ClassType> functor_list_type;
	typedef functor<Ret(T0 t0, T1 t1, T2 t2), BindType, ClassType> functor_type;
	typedef typename functor_type::return_type return_type;

	delegate_list(const functor_type& _functor ,T0 t0, T1 t1, T2 t2)
		:functor_(_functor) , t0_(t0), t1_(t1), t2_(t2)
	{
	}

	Ret operator()()
	{
		return functor_(t0_, t1_, t2_);
	}

	functor_list_type& getFunctor() {return functor_;}

private:
	functor_list_type functor_;

	T0 t0_;T1 t1_;T2 t2_;;

	delegate_list(const delegate_list&);
	delegate_list& operator=(const delegate_list&);
};

/*
	delegate_type
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2
 */
template<typename BindType, typename RtVal, typename ClassType , typename T0, typename T1, typename T2>
struct delegate_type<RtVal (ClassType::*)(T0 t0, T1 t1, T2 t2), BindType>
{
	typedef delegate<RtVal (T0 t0, T1 t1, T2 t2), BindType, ClassType> type;
	typedef delegate_list<RtVal (T0 t0, T1 t1, T2 t2), BindType, ClassType> list_type;
};

template<typename BindType, typename RtVal , typename T0, typename T1, typename T2>
struct delegate_type<RtVal (*)(T0 t0, T1 t1, T2 t2), BindType>
{
	typedef delegate<RtVal (T0 t0, T1 t1, T2 t2), BindType, ClassStub> type;
	typedef delegate_list<RtVal (T0 t0, T1 t1, T2 t2), BindType, ClassStub> list_type;
};




/*********************************************************/

/*********************************************************/
/*
	delegate
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2, typename T3
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2, T3 t3
	FUNCTION_PARA = ,T0 t0, T1 t1, T2 t2, T3 t3
	CLASS_MEMBER  = T0 t0_;T1 t1_;T2 t2_;T3 t3_; 
	CLASS_MEMBER_ASSIGN  = , t0_(t0), t1_(t1), t2_(t2), t3_(t3)
	CLASS_MEMBER_PARA    = t0_, t1_, t2_, t3_
*/
template<typename BindType, typename ClassType, typename Ret , typename T0, typename T1, typename T2, typename T3>
class delegate<Ret(T0 t0, T1 t1, T2 t2, T3 t3), BindType, ClassType>
{
public:
	typedef functor<Ret(T0 t0, T1 t1, T2 t2, T3 t3), BindType, ClassType> functor_type;
	typedef typename functor_type::return_type return_type;

	delegate(const functor_type& _functor ,T0 t0, T1 t1, T2 t2, T3 t3)
		:functor_(_functor) , t0_(t0), t1_(t1), t2_(t2), t3_(t3)
	{

	}

	Ret operator()()
	{
		return functor_(t0_, t1_, t2_, t3_);
	}

	Ret Do()
	{
		return functor_(t0_, t1_, t2_, t3_);
	}

	functor_type& getFunctor() {return functor_;}

private:
	functor_type functor_;

	T0 t0_;T1 t1_;T2 t2_;T3 t3_;;

	delegate(const delegate&);
	delegate& operator=(const delegate&);
};

/*
	delegate_list
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2, typename T3
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2, T3 t3
	FUNCTION_PARA = ,T0 t0, T1 t1, T2 t2, T3 t3
	CLASS_MEMBER  = T0 t0_;T1 t1_;T2 t2_;T3 t3_; 
	CLASS_MEMBER_ASSIGN  = , t0_(t0), t1_(t1), t2_(t2), t3_(t3)
	CLASS_MEMBER_PARA    = t0_, t1_, t2_, t3_
*/
template<typename BindType, typename ClassType, typename Ret , typename T0, typename T1, typename T2, typename T3>
class delegate_list<Ret(T0 t0, T1 t1, T2 t2, T3 t3), BindType, ClassType>
{
public:
	typedef functor_list<Ret(T0 t0, T1 t1, T2 t2, T3 t3), BindType, ClassType> functor_list_type;
	typedef functor<Ret(T0 t0, T1 t1, T2 t2, T3 t3), BindType, ClassType> functor_type;
	typedef typename functor_type::return_type return_type;

	delegate_list(const functor_type& _functor ,T0 t0, T1 t1, T2 t2, T3 t3)
		:functor_(_functor) , t0_(t0), t1_(t1), t2_(t2), t3_(t3)
	{
	}

	Ret operator()()
	{
		return functor_(t0_, t1_, t2_, t3_);
	}

	functor_list_type& getFunctor() {return functor_;}

private:
	functor_list_type functor_;

	T0 t0_;T1 t1_;T2 t2_;T3 t3_;;

	delegate_list(const delegate_list&);
	delegate_list& operator=(const delegate_list&);
};

/*
	delegate_type
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2, typename T3
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2, T3 t3
 */
template<typename BindType, typename RtVal, typename ClassType , typename T0, typename T1, typename T2, typename T3>
struct delegate_type<RtVal (ClassType::*)(T0 t0, T1 t1, T2 t2, T3 t3), BindType>
{
	typedef delegate<RtVal (T0 t0, T1 t1, T2 t2, T3 t3), BindType, ClassType> type;
	typedef delegate_list<RtVal (T0 t0, T1 t1, T2 t2, T3 t3), BindType, ClassType> list_type;
};

template<typename BindType, typename RtVal , typename T0, typename T1, typename T2, typename T3>
struct delegate_type<RtVal (*)(T0 t0, T1 t1, T2 t2, T3 t3), BindType>
{
	typedef delegate<RtVal (T0 t0, T1 t1, T2 t2, T3 t3), BindType, ClassStub> type;
	typedef delegate_list<RtVal (T0 t0, T1 t1, T2 t2, T3 t3), BindType, ClassStub> list_type;
};




/*********************************************************/

/*********************************************************/
/*
	delegate
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2, typename T3, typename T4
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2, T3 t3, T4 t4
	FUNCTION_PARA = ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4
	CLASS_MEMBER  = T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_; 
	CLASS_MEMBER_ASSIGN  = , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4)
	CLASS_MEMBER_PARA    = t0_, t1_, t2_, t3_, t4_
*/
template<typename BindType, typename ClassType, typename Ret , typename T0, typename T1, typename T2, typename T3, typename T4>
class delegate<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4), BindType, ClassType>
{
public:
	typedef functor<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4), BindType, ClassType> functor_type;
	typedef typename functor_type::return_type return_type;

	delegate(const functor_type& _functor ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4)
		:functor_(_functor) , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4)
	{

	}

	Ret operator()()
	{
		return functor_(t0_, t1_, t2_, t3_, t4_);
	}

	Ret Do()
	{
		return functor_(t0_, t1_, t2_, t3_, t4_);
	}

	functor_type& getFunctor() {return functor_;}

private:
	functor_type functor_;

	T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_;;

	delegate(const delegate&);
	delegate& operator=(const delegate&);
};

/*
	delegate_list
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2, typename T3, typename T4
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2, T3 t3, T4 t4
	FUNCTION_PARA = ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4
	CLASS_MEMBER  = T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_; 
	CLASS_MEMBER_ASSIGN  = , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4)
	CLASS_MEMBER_PARA    = t0_, t1_, t2_, t3_, t4_
*/
template<typename BindType, typename ClassType, typename Ret , typename T0, typename T1, typename T2, typename T3, typename T4>
class delegate_list<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4), BindType, ClassType>
{
public:
	typedef functor_list<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4), BindType, ClassType> functor_list_type;
	typedef functor<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4), BindType, ClassType> functor_type;
	typedef typename functor_type::return_type return_type;

	delegate_list(const functor_type& _functor ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4)
		:functor_(_functor) , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4)
	{
	}

	Ret operator()()
	{
		return functor_(t0_, t1_, t2_, t3_, t4_);
	}

	functor_list_type& getFunctor() {return functor_;}

private:
	functor_list_type functor_;

	T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_;;

	delegate_list(const delegate_list&);
	delegate_list& operator=(const delegate_list&);
};

/*
	delegate_type
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2, typename T3, typename T4
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2, T3 t3, T4 t4
 */
template<typename BindType, typename RtVal, typename ClassType , typename T0, typename T1, typename T2, typename T3, typename T4>
struct delegate_type<RtVal (ClassType::*)(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4), BindType>
{
	typedef delegate<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4), BindType, ClassType> type;
	typedef delegate_list<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4), BindType, ClassType> list_type;
};

template<typename BindType, typename RtVal , typename T0, typename T1, typename T2, typename T3, typename T4>
struct delegate_type<RtVal (*)(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4), BindType>
{
	typedef delegate<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4), BindType, ClassStub> type;
	typedef delegate_list<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4), BindType, ClassStub> list_type;
};




/*********************************************************/

/*********************************************************/
/*
	delegate
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5
	FUNCTION_PARA = ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5
	CLASS_MEMBER  = T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_;T5 t5_; 
	CLASS_MEMBER_ASSIGN  = , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5)
	CLASS_MEMBER_PARA    = t0_, t1_, t2_, t3_, t4_, t5_
*/
template<typename BindType, typename ClassType, typename Ret , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
class delegate<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5), BindType, ClassType>
{
public:
	typedef functor<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5), BindType, ClassType> functor_type;
	typedef typename functor_type::return_type return_type;

	delegate(const functor_type& _functor ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
		:functor_(_functor) , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5)
	{

	}

	Ret operator()()
	{
		return functor_(t0_, t1_, t2_, t3_, t4_, t5_);
	}

	Ret Do()
	{
		return functor_(t0_, t1_, t2_, t3_, t4_, t5_);
	}

	functor_type& getFunctor() {return functor_;}

private:
	functor_type functor_;

	T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_;T5 t5_;;

	delegate(const delegate&);
	delegate& operator=(const delegate&);
};

/*
	delegate_list
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5
	FUNCTION_PARA = ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5
	CLASS_MEMBER  = T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_;T5 t5_; 
	CLASS_MEMBER_ASSIGN  = , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5)
	CLASS_MEMBER_PARA    = t0_, t1_, t2_, t3_, t4_, t5_
*/
template<typename BindType, typename ClassType, typename Ret , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
class delegate_list<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5), BindType, ClassType>
{
public:
	typedef functor_list<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5), BindType, ClassType> functor_list_type;
	typedef functor<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5), BindType, ClassType> functor_type;
	typedef typename functor_type::return_type return_type;

	delegate_list(const functor_type& _functor ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5)
		:functor_(_functor) , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5)
	{
	}

	Ret operator()()
	{
		return functor_(t0_, t1_, t2_, t3_, t4_, t5_);
	}

	functor_list_type& getFunctor() {return functor_;}

private:
	functor_list_type functor_;

	T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_;T5 t5_;;

	delegate_list(const delegate_list&);
	delegate_list& operator=(const delegate_list&);
};

/*
	delegate_type
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5
 */
template<typename BindType, typename RtVal, typename ClassType , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
struct delegate_type<RtVal (ClassType::*)(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5), BindType>
{
	typedef delegate<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5), BindType, ClassType> type;
	typedef delegate_list<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5), BindType, ClassType> list_type;
};

template<typename BindType, typename RtVal , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
struct delegate_type<RtVal (*)(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5), BindType>
{
	typedef delegate<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5), BindType, ClassStub> type;
	typedef delegate_list<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5), BindType, ClassStub> list_type;
};




/*********************************************************/

/*********************************************************/
/*
	delegate
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6
	FUNCTION_PARA = ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6
	CLASS_MEMBER  = T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_;T5 t5_;T6 t6_; 
	CLASS_MEMBER_ASSIGN  = , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6)
	CLASS_MEMBER_PARA    = t0_, t1_, t2_, t3_, t4_, t5_, t6_
*/
template<typename BindType, typename ClassType, typename Ret , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
class delegate<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6), BindType, ClassType>
{
public:
	typedef functor<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6), BindType, ClassType> functor_type;
	typedef typename functor_type::return_type return_type;

	delegate(const functor_type& _functor ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
		:functor_(_functor) , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6)
	{

	}

	Ret operator()()
	{
		return functor_(t0_, t1_, t2_, t3_, t4_, t5_, t6_);
	}

	Ret Do()
	{
		return functor_(t0_, t1_, t2_, t3_, t4_, t5_, t6_);
	}

	functor_type& getFunctor() {return functor_;}

private:
	functor_type functor_;

	T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_;T5 t5_;T6 t6_;;

	delegate(const delegate&);
	delegate& operator=(const delegate&);
};

/*
	delegate_list
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6
	FUNCTION_PARA = ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6
	CLASS_MEMBER  = T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_;T5 t5_;T6 t6_; 
	CLASS_MEMBER_ASSIGN  = , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6)
	CLASS_MEMBER_PARA    = t0_, t1_, t2_, t3_, t4_, t5_, t6_
*/
template<typename BindType, typename ClassType, typename Ret , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
class delegate_list<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6), BindType, ClassType>
{
public:
	typedef functor_list<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6), BindType, ClassType> functor_list_type;
	typedef functor<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6), BindType, ClassType> functor_type;
	typedef typename functor_type::return_type return_type;

	delegate_list(const functor_type& _functor ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6)
		:functor_(_functor) , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6)
	{
	}

	Ret operator()()
	{
		return functor_(t0_, t1_, t2_, t3_, t4_, t5_, t6_);
	}

	functor_list_type& getFunctor() {return functor_;}

private:
	functor_list_type functor_;

	T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_;T5 t5_;T6 t6_;;

	delegate_list(const delegate_list&);
	delegate_list& operator=(const delegate_list&);
};

/*
	delegate_type
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6
 */
template<typename BindType, typename RtVal, typename ClassType , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
struct delegate_type<RtVal (ClassType::*)(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6), BindType>
{
	typedef delegate<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6), BindType, ClassType> type;
	typedef delegate_list<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6), BindType, ClassType> list_type;
};

template<typename BindType, typename RtVal , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
struct delegate_type<RtVal (*)(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6), BindType>
{
	typedef delegate<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6), BindType, ClassStub> type;
	typedef delegate_list<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6), BindType, ClassStub> list_type;
};




/*********************************************************/

/*********************************************************/
/*
	delegate
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7
	FUNCTION_PARA = ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7
	CLASS_MEMBER  = T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_;T5 t5_;T6 t6_;T7 t7_; 
	CLASS_MEMBER_ASSIGN  = , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6), t7_(t7)
	CLASS_MEMBER_PARA    = t0_, t1_, t2_, t3_, t4_, t5_, t6_, t7_
*/
template<typename BindType, typename ClassType, typename Ret , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
class delegate<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7), BindType, ClassType>
{
public:
	typedef functor<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7), BindType, ClassType> functor_type;
	typedef typename functor_type::return_type return_type;

	delegate(const functor_type& _functor ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7)
		:functor_(_functor) , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6), t7_(t7)
	{

	}

	Ret operator()()
	{
		return functor_(t0_, t1_, t2_, t3_, t4_, t5_, t6_, t7_);
	}

	Ret Do()
	{
		return functor_(t0_, t1_, t2_, t3_, t4_, t5_, t6_, t7_);
	}

	functor_type& getFunctor() {return functor_;}

private:
	functor_type functor_;

	T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_;T5 t5_;T6 t6_;T7 t7_;;

	delegate(const delegate&);
	delegate& operator=(const delegate&);
};

/*
	delegate_list
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7
	FUNCTION_PARA = ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7
	CLASS_MEMBER  = T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_;T5 t5_;T6 t6_;T7 t7_; 
	CLASS_MEMBER_ASSIGN  = , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6), t7_(t7)
	CLASS_MEMBER_PARA    = t0_, t1_, t2_, t3_, t4_, t5_, t6_, t7_
*/
template<typename BindType, typename ClassType, typename Ret , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
class delegate_list<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7), BindType, ClassType>
{
public:
	typedef functor_list<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7), BindType, ClassType> functor_list_type;
	typedef functor<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7), BindType, ClassType> functor_type;
	typedef typename functor_type::return_type return_type;

	delegate_list(const functor_type& _functor ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7)
		:functor_(_functor) , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6), t7_(t7)
	{
	}

	Ret operator()()
	{
		return functor_(t0_, t1_, t2_, t3_, t4_, t5_, t6_, t7_);
	}

	functor_list_type& getFunctor() {return functor_;}

private:
	functor_list_type functor_;

	T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_;T5 t5_;T6 t6_;T7 t7_;;

	delegate_list(const delegate_list&);
	delegate_list& operator=(const delegate_list&);
};

/*
	delegate_type
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7
 */
template<typename BindType, typename RtVal, typename ClassType , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
struct delegate_type<RtVal (ClassType::*)(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7), BindType>
{
	typedef delegate<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7), BindType, ClassType> type;
	typedef delegate_list<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7), BindType, ClassType> list_type;
};

template<typename BindType, typename RtVal , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
struct delegate_type<RtVal (*)(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7), BindType>
{
	typedef delegate<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7), BindType, ClassStub> type;
	typedef delegate_list<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7), BindType, ClassStub> list_type;
};




/*********************************************************/

/*********************************************************/
/*
	delegate
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8
	FUNCTION_PARA = ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8
	CLASS_MEMBER  = T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_;T5 t5_;T6 t6_;T7 t7_;T8 t8_; 
	CLASS_MEMBER_ASSIGN  = , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6), t7_(t7), t8_(t8)
	CLASS_MEMBER_PARA    = t0_, t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_
*/
template<typename BindType, typename ClassType, typename Ret , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
class delegate<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8), BindType, ClassType>
{
public:
	typedef functor<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8), BindType, ClassType> functor_type;
	typedef typename functor_type::return_type return_type;

	delegate(const functor_type& _functor ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8)
		:functor_(_functor) , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6), t7_(t7), t8_(t8)
	{

	}

	Ret operator()()
	{
		return functor_(t0_, t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_);
	}

	Ret Do()
	{
		return functor_(t0_, t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_);
	}

	functor_type& getFunctor() {return functor_;}

private:
	functor_type functor_;

	T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_;T5 t5_;T6 t6_;T7 t7_;T8 t8_;;

	delegate(const delegate&);
	delegate& operator=(const delegate&);
};

/*
	delegate_list
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8
	FUNCTION_PARA = ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8
	CLASS_MEMBER  = T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_;T5 t5_;T6 t6_;T7 t7_;T8 t8_; 
	CLASS_MEMBER_ASSIGN  = , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6), t7_(t7), t8_(t8)
	CLASS_MEMBER_PARA    = t0_, t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_
*/
template<typename BindType, typename ClassType, typename Ret , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
class delegate_list<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8), BindType, ClassType>
{
public:
	typedef functor_list<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8), BindType, ClassType> functor_list_type;
	typedef functor<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8), BindType, ClassType> functor_type;
	typedef typename functor_type::return_type return_type;

	delegate_list(const functor_type& _functor ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8)
		:functor_(_functor) , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6), t7_(t7), t8_(t8)
	{
	}

	Ret operator()()
	{
		return functor_(t0_, t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_);
	}

	functor_list_type& getFunctor() {return functor_;}

private:
	functor_list_type functor_;

	T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_;T5 t5_;T6 t6_;T7 t7_;T8 t8_;;

	delegate_list(const delegate_list&);
	delegate_list& operator=(const delegate_list&);
};

/*
	delegate_type
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8
 */
template<typename BindType, typename RtVal, typename ClassType , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
struct delegate_type<RtVal (ClassType::*)(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8), BindType>
{
	typedef delegate<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8), BindType, ClassType> type;
	typedef delegate_list<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8), BindType, ClassType> list_type;
};

template<typename BindType, typename RtVal , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
struct delegate_type<RtVal (*)(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8), BindType>
{
	typedef delegate<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8), BindType, ClassStub> type;
	typedef delegate_list<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8), BindType, ClassStub> list_type;
};




/*********************************************************/

/*********************************************************/
/*
	delegate
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
	FUNCTION_PARA = ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
	CLASS_MEMBER  = T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_;T5 t5_;T6 t6_;T7 t7_;T8 t8_;T9 t9_; 
	CLASS_MEMBER_ASSIGN  = , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6), t7_(t7), t8_(t8), t9_(t9)
	CLASS_MEMBER_PARA    = t0_, t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_, t9_
*/
template<typename BindType, typename ClassType, typename Ret , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
class delegate<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9), BindType, ClassType>
{
public:
	typedef functor<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9), BindType, ClassType> functor_type;
	typedef typename functor_type::return_type return_type;

	delegate(const functor_type& _functor ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9)
		:functor_(_functor) , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6), t7_(t7), t8_(t8), t9_(t9)
	{

	}

	Ret operator()()
	{
		return functor_(t0_, t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_, t9_);
	}

	Ret Do()
	{
		return functor_(t0_, t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_, t9_);
	}

	functor_type& getFunctor() {return functor_;}

private:
	functor_type functor_;

	T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_;T5 t5_;T6 t6_;T7 t7_;T8 t8_;T9 t9_;;

	delegate(const delegate&);
	delegate& operator=(const delegate&);
};

/*
	delegate_list
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
	FUNCTION_PARA = ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
	CLASS_MEMBER  = T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_;T5 t5_;T6 t6_;T7 t7_;T8 t8_;T9 t9_; 
	CLASS_MEMBER_ASSIGN  = , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6), t7_(t7), t8_(t8), t9_(t9)
	CLASS_MEMBER_PARA    = t0_, t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_, t9_
*/
template<typename BindType, typename ClassType, typename Ret , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
class delegate_list<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9), BindType, ClassType>
{
public:
	typedef functor_list<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9), BindType, ClassType> functor_list_type;
	typedef functor<Ret(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9), BindType, ClassType> functor_type;
	typedef typename functor_type::return_type return_type;

	delegate_list(const functor_type& _functor ,T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9)
		:functor_(_functor) , t0_(t0), t1_(t1), t2_(t2), t3_(t3), t4_(t4), t5_(t5), t6_(t6), t7_(t7), t8_(t8), t9_(t9)
	{
	}

	Ret operator()()
	{
		return functor_(t0_, t1_, t2_, t3_, t4_, t5_, t6_, t7_, t8_, t9_);
	}

	functor_list_type& getFunctor() {return functor_;}

private:
	functor_list_type functor_;

	T0 t0_;T1 t1_;T2 t2_;T3 t3_;T4 t4_;T5 t5_;T6 t6_;T7 t7_;T8 t8_;T9 t9_;;

	delegate_list(const delegate_list&);
	delegate_list& operator=(const delegate_list&);
};

/*
	delegate_type
	TEMPLATE_ARGS = , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9
	FUNCTION_ARGS = T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9
 */
template<typename BindType, typename RtVal, typename ClassType , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
struct delegate_type<RtVal (ClassType::*)(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9), BindType>
{
	typedef delegate<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9), BindType, ClassType> type;
	typedef delegate_list<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9), BindType, ClassType> list_type;
};

template<typename BindType, typename RtVal , typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
struct delegate_type<RtVal (*)(T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9), BindType>
{
	typedef delegate<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9), BindType, ClassStub> type;
	typedef delegate_list<RtVal (T0 t0, T1 t1, T2 t2, T3 t3, T4 t4, T5 t5, T6 t6, T7 t7, T8 t8, T9 t9), BindType, ClassStub> list_type;
};




/*********************************************************/

